<?xml version='1.0' encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <link href="cpip.css" rel="stylesheet" type="text/css" />
    <title>File: /Users/paulross/dev/linux/linux-3.13/include/linux/radix-tree.h</title>
  </head>
  <body>
    <h1>File: /Users/paulross/dev/linux/linux-3.13/include/linux/radix-tree.h</h1>
    <p>Green shading in the line number column
means the source is part of the translation unit, red means it is conditionally excluded.
Highlighted line numbers link to the translation unit page. Highlighted macros link to
the macro page.</p>
    <pre><a name="1" /><span class="True">       1:</span> <span class="k">/*</span>
<a name="2" /><span class="True">       2:</span> <span class="k"> * Copyright (C) 2001 Momchil Velikov</span>
<a name="3" /><span class="True">       3:</span> <span class="k"> * Portions Copyright (C) 2001 Christoph Hellwig</span>
<a name="4" /><span class="True">       4:</span> <span class="k"> * Copyright (C) 2006 Nick Piggin</span>
<a name="5" /><span class="True">       5:</span> <span class="k"> * Copyright (C) 2012 Konstantin Khlebnikov</span>
<a name="6" /><span class="True">       6:</span> <span class="k"> *</span>
<a name="7" /><span class="True">       7:</span> <span class="k"> * This program is free software; you can redistribute it and/or</span>
<a name="8" /><span class="True">       8:</span> <span class="k"> * modify it under the terms of the GNU General Public License as</span>
<a name="9" /><span class="True">       9:</span> <span class="k"> * published by the Free Software Foundation; either version 2, or (at</span>
<a name="10" /><span class="True">      10:</span> <span class="k"> * your option) any later version.</span>
<a name="11" /><span class="True">      11:</span> <span class="k"> * </span>
<a name="12" /><span class="True">      12:</span> <span class="k"> * This program is distributed in the hope that it will be useful, but</span>
<a name="13" /><span class="True">      13:</span> <span class="k"> * WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<a name="14" /><span class="True">      14:</span> <span class="k"> * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU</span>
<a name="15" /><span class="True">      15:</span> <span class="k"> * General Public License for more details.</span>
<a name="16" /><span class="True">      16:</span> <span class="k"> * </span>
<a name="17" /><span class="True">      17:</span> <span class="k"> * You should have received a copy of the GNU General Public License</span>
<a name="18" /><span class="True">      18:</span> <span class="k"> * along with this program; if not, write to the Free Software</span>
<a name="19" /><span class="True">      19:</span> <span class="k"> * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.</span>
<a name="20" /><span class="True">      20:</span> <span class="k"> */</span>
<a name="21" /><span class="True">      21:</span> <span class="f">#</span><span class="n">ifndef</span> <a href="cpu.c_macros_noref.html#_X0xJTlVYX1JBRElYX1RSRUVfSF8w"><span class="b">_LINUX_RADIX_TREE_H</span></a>
<a name="22" /><span class="True">      22:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_X0xJTlVYX1JBRElYX1RSRUVfSF8w"><span class="b">_LINUX_RADIX_TREE_H</span></a>
<a name="23" /><span class="True">      23:</span> 
<a name="24" /><span class="True">      24:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">preempt</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="25" /><span class="True">      25:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">types</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="26" /><span class="True">      26:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">bug</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="27" /><span class="True">      27:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">kernel</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="28" /><span class="True">      28:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">rcupdate</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="29" /><span class="True">      29:</span> 
<a name="30" /><span class="True">      30:</span> <span class="k">/*</span>
<a name="31" /><span class="True">      31:</span> <span class="k"> * An indirect pointer (root-&gt;rnode pointing to a radix_tree_node, rather</span>
<a name="32" /><span class="True">      32:</span> <span class="k"> * than a data item) is signalled by the low bit set in the root-&gt;rnode</span>
<a name="33" /><span class="True">      33:</span> <span class="k"> * pointer.</span>
<a name="34" /><span class="True">      34:</span> <span class="k"> *</span>
<a name="35" /><span class="True">      35:</span> <span class="k"> * In this case root-&gt;height is &gt; 0, but the indirect pointer tests are</span>
<a name="36" /><span class="True">      36:</span> <span class="k"> * needed for RCU lookups (because root-&gt;height is unreliable). The only</span>
<a name="37" /><span class="True">      37:</span> <span class="k"> * time callers need worry about this is when doing a lookup_slot under</span>
<a name="38" /><span class="True">      38:</span> <span class="k"> * RCU.</span>
<a name="39" /><span class="True">      39:</span> <span class="k"> *</span>
<a name="40" /><span class="True">      40:</span> <span class="k"> * Indirect pointer in fact is also used to tag the last pointer of a node</span>
<a name="41" /><span class="True">      41:</span> <span class="k"> * when it is shrunk, before we rcu free the node. See shrink code for</span>
<a name="42" /><span class="True">      42:</span> <span class="k"> * details.</span>
<a name="43" /><span class="True">      43:</span> <span class="k"> */</span>
<a name="44" /><span class="True">      44:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JTkRJUkVDVF9QVFJfMA__"><span class="b">RADIX_TREE_INDIRECT_PTR</span></a>        <span class="c">1</span>
<a name="45" /><span class="True">      45:</span> <span class="k">/*</span>
<a name="46" /><span class="True">      46:</span> <span class="k"> * A common use of the radix tree is to store pointers to struct pages;</span>
<a name="47" /><span class="True">      47:</span> <span class="k"> * but shmem/tmpfs needs also to store swap entries in the same tree:</span>
<a name="48" /><span class="True">      48:</span> <span class="k"> * those are marked as exceptional entries to distinguish them.</span>
<a name="49" /><span class="True">      49:</span> <span class="k"> * EXCEPTIONAL_ENTRY tests the bit, EXCEPTIONAL_SHIFT shifts content past it.</span>
<a name="50" /><span class="True">      50:</span> <span class="k"> */</span>
<a name="51" /><span class="True">      51:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9FWENFUFRJT05BTF9FTlRSWV8w"><span class="b">RADIX_TREE_EXCEPTIONAL_ENTRY</span></a>    <span class="c">2</span>
<a name="52" /><span class="True">      52:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_UkFESVhfVFJFRV9FWENFUFRJT05BTF9TSElGVF8w"><span class="b">RADIX_TREE_EXCEPTIONAL_SHIFT</span></a>    <span class="c">2</span>
<a name="53" /><span class="True">      53:</span> 
<a name="54" /><span class="True">      54:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">radix_tree_is_indirect_ptr</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="b">ptr</span><span class="f">)</span>
<a name="55" /><span class="True">      55:</span> <span class="f">{</span>
<a name="56" /><span class="True">      56:</span>     <span class="m">return</span> <span class="f">(</span><span class="m">int</span><span class="f">)</span><span class="f">(</span><span class="f">(</span><span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="b">ptr</span> <span class="f">&amp;</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JTkRJUkVDVF9QVFJfMA__"><span class="b">RADIX_TREE_INDIRECT_PTR</span></a><span class="f">)</span><span class="f">;</span>
<a name="57" /><span class="True">      57:</span> <span class="f">}</span>
<a name="58" /><span class="True">      58:</span> 
<a name="59" /><span class="True">      59:</span> <span class="k">/*** radix-tree API starts here ***/</span>
<a name="60" /><span class="True">      60:</span> 
<a name="61" /><span class="True">      61:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_UkFESVhfVFJFRV9NQVhfVEFHU18w"><span class="b">RADIX_TREE_MAX_TAGS</span></a> <span class="c">3</span>
<a name="62" /><span class="True">      62:</span> 
<a name="63" /><span class="True">      63:</span> <span class="k">/* root tags are stored in gfp_mask, shifted by __GFP_BITS_SHIFT */</span>
<a name="64" /><span class="True">      64:</span> <span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">{</span>
<a name="65" /><span class="True">      65:</span>     <span class="m">unsigned</span> <span class="m">int</span>        <span class="b">height</span><span class="f">;</span>
<a name="66" /><span class="True">      66:</span>     <span class="b">gfp_t</span>            <span class="b">gfp_mask</span><span class="f">;</span>
<a name="67" /><span class="True">      67:</span>     <span class="m">struct</span> <span class="b">radix_tree_node</span>    <a href="cpu.c_macros_ref.html#_X19yY3VfMA__"><span class="b">__rcu</span></a> <span class="f">*</span><span class="b">rnode</span><span class="f">;</span>
<a name="68" /><span class="True">      68:</span> <span class="f">}</span><span class="f">;</span>
<a name="69" /><span class="True">      69:</span> 
<a name="70" /><span class="True">      70:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_UkFESVhfVFJFRV9JTklUXzA_"><span class="b">RADIX_TREE_INIT</span></a><span class="f">(</span><span class="b">mask</span><span class="f">)</span>    <span class="f">{</span>                    \
<a name="71" /><span class="True">      71:</span>     <span class="f">.</span><span class="b">height</span> <span class="f">=</span> <span class="c">0</span><span class="f">,</span>                            \
<a name="72" /><span class="True">      72:</span>     <span class="f">.</span><span class="b">gfp_mask</span> <span class="f">=</span> <span class="f">(</span><span class="b">mask</span><span class="f">)</span><span class="f">,</span>                        \
<a name="73" /><span class="True">      73:</span>     <span class="f">.</span><span class="b">rnode</span> <span class="f">=</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">,</span>                            \
<a name="74" /><span class="True">      74:</span> <span class="f">}</span>
<a name="75" /><span class="True">      75:</span> 
<a name="76" /><span class="True">      76:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_UkFESVhfVFJFRV8w"><span class="b">RADIX_TREE</span></a><span class="f">(</span><span class="b">name</span><span class="f">,</span> <span class="b">mask</span><span class="f">)</span> \
<a name="77" /><span class="True">      77:</span>     <span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="b">name</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_UkFESVhfVFJFRV9JTklUXzA_"><span class="b">RADIX_TREE_INIT</span></a><span class="f">(</span><span class="b">mask</span><span class="f">)</span>
<a name="78" /><span class="True">      78:</span> 
<a name="79" /><span class="True">      79:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_SU5JVF9SQURJWF9UUkVFXzA_"><span class="b">INIT_RADIX_TREE</span></a><span class="f">(</span><span class="b">root</span><span class="f">,</span> <span class="b">mask</span><span class="f">)</span>                    \
<a name="80" /><span class="True">      80:</span> <span class="m">do</span> <span class="f">{</span>                                    \
<a name="81" /><span class="True">      81:</span>     <span class="f">(</span><span class="b">root</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">height</span> <span class="f">=</span> <span class="c">0</span><span class="f">;</span>                        \
<a name="82" /><span class="True">      82:</span>     <span class="f">(</span><span class="b">root</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">gfp_mask</span> <span class="f">=</span> <span class="f">(</span><span class="b">mask</span><span class="f">)</span><span class="f">;</span>                    \
<a name="83" /><span class="True">      83:</span>     <span class="f">(</span><span class="b">root</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">rnode</span> <span class="f">=</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>                        \
<a name="84" /><span class="True">      84:</span> <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="85" /><span class="True">      85:</span> 
<a name="86" /><span class="True">      86:</span> <span class="k">/**</span>
<a name="87" /><span class="True">      87:</span> <span class="k"> * Radix-tree synchronization</span>
<a name="88" /><span class="True">      88:</span> <span class="k"> *</span>
<a name="89" /><span class="True">      89:</span> <span class="k"> * The radix-tree API requires that users provide all synchronisation (with</span>
<a name="90" /><span class="True">      90:</span> <span class="k"> * specific exceptions, noted below).</span>
<a name="91" /><span class="True">      91:</span> <span class="k"> *</span>
<a name="92" /><span class="True">      92:</span> <span class="k"> * Synchronization of access to the data items being stored in the tree, and</span>
<a name="93" /><span class="True">      93:</span> <span class="k"> * management of their lifetimes must be completely managed by API users.</span>
<a name="94" /><span class="True">      94:</span> <span class="k"> *</span>
<a name="95" /><span class="True">      95:</span> <span class="k"> * For API usage, in general,</span>
<a name="96" /><span class="True">      96:</span> <span class="k"> * - any function _modifying_ the tree or tags (inserting or deleting</span>
<a name="97" /><span class="True">      97:</span> <span class="k"> *   items, setting or clearing tags) must exclude other modifications, and</span>
<a name="98" /><span class="True">      98:</span> <span class="k"> *   exclude any functions reading the tree.</span>
<a name="99" /><span class="True">      99:</span> <span class="k"> * - any function _reading_ the tree or tags (looking up items or tags,</span>
<a name="100" /><span class="True">     100:</span> <span class="k"> *   gang lookups) must exclude modifications to the tree, but may occur</span>
<a name="101" /><span class="True">     101:</span> <span class="k"> *   concurrently with other readers.</span>
<a name="102" /><span class="True">     102:</span> <span class="k"> *</span>
<a name="103" /><span class="True">     103:</span> <span class="k"> * The notable exceptions to this rule are the following functions:</span>
<a name="104" /><span class="True">     104:</span> <span class="k"> * radix_tree_lookup</span>
<a name="105" /><span class="True">     105:</span> <span class="k"> * radix_tree_lookup_slot</span>
<a name="106" /><span class="True">     106:</span> <span class="k"> * radix_tree_tag_get</span>
<a name="107" /><span class="True">     107:</span> <span class="k"> * radix_tree_gang_lookup</span>
<a name="108" /><span class="True">     108:</span> <span class="k"> * radix_tree_gang_lookup_slot</span>
<a name="109" /><span class="True">     109:</span> <span class="k"> * radix_tree_gang_lookup_tag</span>
<a name="110" /><span class="True">     110:</span> <span class="k"> * radix_tree_gang_lookup_tag_slot</span>
<a name="111" /><span class="True">     111:</span> <span class="k"> * radix_tree_tagged</span>
<a name="112" /><span class="True">     112:</span> <span class="k"> *</span>
<a name="113" /><span class="True">     113:</span> <span class="k"> * The first 7 functions are able to be called locklessly, using RCU. The</span>
<a name="114" /><span class="True">     114:</span> <span class="k"> * caller must ensure calls to these functions are made within rcu_read_lock()</span>
<a name="115" /><span class="True">     115:</span> <span class="k"> * regions. Other readers (lock-free or otherwise) and modifications may be</span>
<a name="116" /><span class="True">     116:</span> <span class="k"> * running concurrently.</span>
<a name="117" /><span class="True">     117:</span> <span class="k"> *</span>
<a name="118" /><span class="True">     118:</span> <span class="k"> * It is still required that the caller manage the synchronization and lifetimes</span>
<a name="119" /><span class="True">     119:</span> <span class="k"> * of the items. So if RCU lock-free lookups are used, typically this would mean</span>
<a name="120" /><span class="True">     120:</span> <span class="k"> * that the items have their own locks, or are amenable to lock-free access; and</span>
<a name="121" /><span class="True">     121:</span> <span class="k"> * that the items are freed by RCU (or only freed after having been deleted from</span>
<a name="122" /><span class="True">     122:</span> <span class="k"> * the radix tree *and* a synchronize_rcu() grace period).</span>
<a name="123" /><span class="True">     123:</span> <span class="k"> *</span>
<a name="124" /><span class="True">     124:</span> <span class="k"> * (Note, rcu_assign_pointer and rcu_dereference are not needed to control</span>
<a name="125" /><span class="True">     125:</span> <span class="k"> * access to data items when inserting into or looking up from the radix tree)</span>
<a name="126" /><span class="True">     126:</span> <span class="k"> *</span>
<a name="127" /><span class="True">     127:</span> <span class="k"> * Note that the value returned by radix_tree_tag_get() may not be relied upon</span>
<a name="128" /><span class="True">     128:</span> <span class="k"> * if only the RCU read lock is held.  Functions to set/clear tags and to</span>
<a name="129" /><span class="True">     129:</span> <span class="k"> * delete nodes running concurrently with it may affect its result such that</span>
<a name="130" /><span class="True">     130:</span> <span class="k"> * two consecutive reads in the same locked section may return different</span>
<a name="131" /><span class="True">     131:</span> <span class="k"> * values.  If reliability is required, modification functions must also be</span>
<a name="132" /><span class="True">     132:</span> <span class="k"> * excluded from concurrency.</span>
<a name="133" /><span class="True">     133:</span> <span class="k"> *</span>
<a name="134" /><span class="True">     134:</span> <span class="k"> * radix_tree_tagged is able to be called without locking or RCU.</span>
<a name="135" /><span class="True">     135:</span> <span class="k"> */</span>
<a name="136" /><span class="True">     136:</span> 
<a name="137" /><span class="True">     137:</span> <span class="k">/**</span>
<a name="138" /><span class="True">     138:</span> <span class="k"> * radix_tree_deref_slot    - dereference a slot</span>
<a name="139" /><span class="True">     139:</span> <span class="k"> * @pslot:    pointer to slot, returned by radix_tree_lookup_slot</span>
<a name="140" /><span class="True">     140:</span> <span class="k"> * Returns:    item that was stored in that slot with any direct pointer flag</span>
<a name="141" /><span class="True">     141:</span> <span class="k"> *        removed.</span>
<a name="142" /><span class="True">     142:</span> <span class="k"> *</span>
<a name="143" /><span class="True">     143:</span> <span class="k"> * For use with radix_tree_lookup_slot().  Caller must hold tree at least read</span>
<a name="144" /><span class="True">     144:</span> <span class="k"> * locked across slot lookup and dereference. Not required if write lock is</span>
<a name="145" /><span class="True">     145:</span> <span class="k"> * held (ie. items cannot be concurrently inserted).</span>
<a name="146" /><span class="True">     146:</span> <span class="k"> *</span>
<a name="147" /><span class="True">     147:</span> <span class="k"> * radix_tree_deref_retry must be used to confirm validity of the pointer if</span>
<a name="148" /><span class="True">     148:</span> <span class="k"> * only the read lock is held.</span>
<a name="149" /><span class="True">     149:</span> <span class="k"> */</span>
<a name="150" /><span class="True">     150:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="f">*</span><span class="b">radix_tree_deref_slot</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">pslot</span><span class="f">)</span>
<a name="151" /><span class="True">     151:</span> <span class="f">{</span>
<a name="152" /><span class="True">     152:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_cmN1X2RlcmVmZXJlbmNlXzA_"><span class="b">rcu_dereference</span></a><span class="f">(</span><span class="f">*</span><span class="b">pslot</span><span class="f">)</span><span class="f">;</span>
<a name="153" /><span class="True">     153:</span> <span class="f">}</span>
<a name="154" /><span class="True">     154:</span> 
<a name="155" /><span class="True">     155:</span> <span class="k">/**</span>
<a name="156" /><span class="True">     156:</span> <span class="k"> * radix_tree_deref_slot_protected    - dereference a slot without RCU lock but with tree lock held</span>
<a name="157" /><span class="True">     157:</span> <span class="k"> * @pslot:    pointer to slot, returned by radix_tree_lookup_slot</span>
<a name="158" /><span class="True">     158:</span> <span class="k"> * Returns:    item that was stored in that slot with any direct pointer flag</span>
<a name="159" /><span class="True">     159:</span> <span class="k"> *        removed.</span>
<a name="160" /><span class="True">     160:</span> <span class="k"> *</span>
<a name="161" /><span class="True">     161:</span> <span class="k"> * Similar to radix_tree_deref_slot but only used during migration when a pages</span>
<a name="162" /><span class="True">     162:</span> <span class="k"> * mapping is being moved. The caller does not hold the RCU read lock but it</span>
<a name="163" /><span class="True">     163:</span> <span class="k"> * must hold the tree lock to prevent parallel updates.</span>
<a name="164" /><span class="True">     164:</span> <span class="k"> */</span>
<a name="165" /><span class="True">     165:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="f">*</span><span class="b">radix_tree_deref_slot_protected</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">pslot</span><span class="f">,</span>
<a name="166" /><span class="True">     166:</span>                             <span class="b">spinlock_t</span> <span class="f">*</span><span class="b">treelock</span><span class="f">)</span>
<a name="167" /><span class="True">     167:</span> <span class="f">{</span>
<a name="168" /><span class="True">     168:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_cmN1X2RlcmVmZXJlbmNlX3Byb3RlY3RlZF8w"><span class="b">rcu_dereference_protected</span></a><span class="f">(</span><span class="f">*</span><span class="b">pslot</span><span class="f">,</span> <span class="b">lockdep_is_held</span><span class="f">(</span><span class="b">treelock</span><span class="f">)</span><span class="f">)</span><span class="f">;</span>
<a name="169" /><span class="True">     169:</span> <span class="f">}</span>
<a name="170" /><span class="True">     170:</span> 
<a name="171" /><span class="True">     171:</span> <span class="k">/**</span>
<a name="172" /><span class="True">     172:</span> <span class="k"> * radix_tree_deref_retry    - check radix_tree_deref_slot</span>
<a name="173" /><span class="True">     173:</span> <span class="k"> * @arg:    pointer returned by radix_tree_deref_slot</span>
<a name="174" /><span class="True">     174:</span> <span class="k"> * Returns:    0 if retry is not required, otherwise retry is required</span>
<a name="175" /><span class="True">     175:</span> <span class="k"> *</span>
<a name="176" /><span class="True">     176:</span> <span class="k"> * radix_tree_deref_retry must be used with radix_tree_deref_slot.</span>
<a name="177" /><span class="True">     177:</span> <span class="k"> */</span>
<a name="178" /><span class="True">     178:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">radix_tree_deref_retry</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="b">arg</span><span class="f">)</span>
<a name="179" /><span class="True">     179:</span> <span class="f">{</span>
<a name="180" /><span class="True">     180:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_dW5saWtlbHlfMA__"><span class="b">unlikely</span></a><span class="f">(</span><span class="f">(</span><span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="b">arg</span> <span class="f">&amp;</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JTkRJUkVDVF9QVFJfMA__"><span class="b">RADIX_TREE_INDIRECT_PTR</span></a><span class="f">)</span><span class="f">;</span>
<a name="181" /><span class="True">     181:</span> <span class="f">}</span>
<a name="182" /><span class="True">     182:</span> 
<a name="183" /><span class="True">     183:</span> <span class="k">/**</span>
<a name="184" /><span class="True">     184:</span> <span class="k"> * radix_tree_exceptional_entry    - radix_tree_deref_slot gave exceptional entry?</span>
<a name="185" /><span class="True">     185:</span> <span class="k"> * @arg:    value returned by radix_tree_deref_slot</span>
<a name="186" /><span class="True">     186:</span> <span class="k"> * Returns:    0 if well-aligned pointer, non-0 if exceptional entry.</span>
<a name="187" /><span class="True">     187:</span> <span class="k"> */</span>
<a name="188" /><span class="True">     188:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">radix_tree_exceptional_entry</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="b">arg</span><span class="f">)</span>
<a name="189" /><span class="True">     189:</span> <span class="f">{</span>
<a name="190" /><span class="True">     190:</span>     <span class="k">/* Not unlikely because radix_tree_exception often tested first */</span>
<a name="191" /><span class="True">     191:</span>     <span class="m">return</span> <span class="f">(</span><span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="b">arg</span> <span class="f">&amp;</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9FWENFUFRJT05BTF9FTlRSWV8w"><span class="b">RADIX_TREE_EXCEPTIONAL_ENTRY</span></a><span class="f">;</span>
<a name="192" /><span class="True">     192:</span> <span class="f">}</span>
<a name="193" /><span class="True">     193:</span> 
<a name="194" /><span class="True">     194:</span> <span class="k">/**</span>
<a name="195" /><span class="True">     195:</span> <span class="k"> * radix_tree_exception    - radix_tree_deref_slot returned either exception?</span>
<a name="196" /><span class="True">     196:</span> <span class="k"> * @arg:    value returned by radix_tree_deref_slot</span>
<a name="197" /><span class="True">     197:</span> <span class="k"> * Returns:    0 if well-aligned pointer, non-0 if either kind of exception.</span>
<a name="198" /><span class="True">     198:</span> <span class="k"> */</span>
<a name="199" /><span class="True">     199:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">radix_tree_exception</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="b">arg</span><span class="f">)</span>
<a name="200" /><span class="True">     200:</span> <span class="f">{</span>
<a name="201" /><span class="True">     201:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_dW5saWtlbHlfMA__"><span class="b">unlikely</span></a><span class="f">(</span><span class="f">(</span><span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="b">arg</span> <span class="f">&amp;</span>
<a name="202" /><span class="True">     202:</span>         <span class="f">(</span><a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JTkRJUkVDVF9QVFJfMA__"><span class="b">RADIX_TREE_INDIRECT_PTR</span></a> <span class="f">|</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9FWENFUFRJT05BTF9FTlRSWV8w"><span class="b">RADIX_TREE_EXCEPTIONAL_ENTRY</span></a><span class="f">)</span><span class="f">)</span><span class="f">;</span>
<a name="203" /><span class="True">     203:</span> <span class="f">}</span>
<a name="204" /><span class="True">     204:</span> 
<a name="205" /><span class="True">     205:</span> <span class="k">/**</span>
<a name="206" /><span class="True">     206:</span> <span class="k"> * radix_tree_replace_slot    - replace item in a slot</span>
<a name="207" /><span class="True">     207:</span> <span class="k"> * @pslot:    pointer to slot, returned by radix_tree_lookup_slot</span>
<a name="208" /><span class="True">     208:</span> <span class="k"> * @item:    new item to store in the slot.</span>
<a name="209" /><span class="True">     209:</span> <span class="k"> *</span>
<a name="210" /><span class="True">     210:</span> <span class="k"> * For use with radix_tree_lookup_slot().  Caller must hold tree write locked</span>
<a name="211" /><span class="True">     211:</span> <span class="k"> * across slot lookup and replacement.</span>
<a name="212" /><span class="True">     212:</span> <span class="k"> */</span>
<a name="213" /><span class="True">     213:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">radix_tree_replace_slot</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">pslot</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="b">item</span><span class="f">)</span>
<a name="214" /><span class="True">     214:</span> <span class="f">{</span>
<a name="215" /><span class="True">     215:</span>     <a href="cpu.c_macros_ref.html#_QlVHX09OXzA_"><span class="b">BUG_ON</span></a><span class="f">(</span><span class="b">radix_tree_is_indirect_ptr</span><span class="f">(</span><span class="b">item</span><span class="f">)</span><span class="f">)</span><span class="f">;</span>
<a name="216" /><span class="True">     216:</span>     <a href="cpu.c_macros_ref.html#_cmN1X2Fzc2lnbl9wb2ludGVyXzA_"><span class="b">rcu_assign_pointer</span></a><span class="f">(</span><span class="f">*</span><span class="b">pslot</span><span class="f">,</span> <span class="b">item</span><span class="f">)</span><span class="f">;</span>
<a name="217" /><span class="True">     217:</span> <span class="f">}</span>
<a name="218" /><span class="True">     218:</span> 
<a name="219" /><span class="True">     219:</span> <span class="m">int</span> <span class="b">radix_tree_insert</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">)</span><span class="f">;</span>
<a name="220" /><span class="True">     220:</span> <span class="m">void</span> <span class="f">*</span><span class="b">radix_tree_lookup</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="f">;</span>
<a name="221" /><span class="True">     221:</span> <span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">radix_tree_lookup_slot</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="f">;</span>
<a name="222" /><span class="True">     222:</span> <span class="m">void</span> <span class="f">*</span><span class="b">radix_tree_delete</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span><span class="f">)</span><span class="f">;</span>
<a name="223" /><span class="True">     223:</span> <span class="m">unsigned</span> <span class="m">int</span>
<a name="224" /><span class="True">     224:</span> <span class="b">radix_tree_gang_lookup</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">results</span><span class="f">,</span>
<a name="225" /><span class="True">     225:</span>             <span class="m">unsigned</span> <span class="m">long</span> <span class="b">first_index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">max_items</span><span class="f">)</span><span class="f">;</span>
<a name="226" /><span class="True">     226:</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">radix_tree_gang_lookup_slot</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="227" /><span class="True">     227:</span>             <span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="f">*</span><span class="b">results</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="f">*</span><span class="b">indices</span><span class="f">,</span>
<a name="228" /><span class="True">     228:</span>             <span class="m">unsigned</span> <span class="m">long</span> <span class="b">first_index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">max_items</span><span class="f">)</span><span class="f">;</span>
<a name="229" /><span class="True">     229:</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">radix_tree_next_hole</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="230" /><span class="True">     230:</span>                 <span class="m">unsigned</span> <span class="m">long</span> <span class="b">index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">max_scan</span><span class="f">)</span><span class="f">;</span>
<a name="231" /><span class="True">     231:</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">radix_tree_prev_hole</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="232" /><span class="True">     232:</span>                 <span class="m">unsigned</span> <span class="m">long</span> <span class="b">index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">max_scan</span><span class="f">)</span><span class="f">;</span>
<a name="233" /><span class="True">     233:</span> <span class="m">int</span> <span class="b">radix_tree_preload</span><span class="f">(</span><span class="b">gfp_t</span> <span class="b">gfp_mask</span><span class="f">)</span><span class="f">;</span>
<a name="234" /><span class="True">     234:</span> <span class="m">int</span> <span class="b">radix_tree_maybe_preload</span><span class="f">(</span><span class="b">gfp_t</span> <span class="b">gfp_mask</span><span class="f">)</span><span class="f">;</span>
<a name="235" /><span class="True">     235:</span> <span class="m">void</span> <span class="b">radix_tree_init</span><span class="f">(</span><span class="m">void</span><span class="f">)</span><span class="f">;</span>
<a name="236" /><span class="True">     236:</span> <span class="m">void</span> <span class="f">*</span><span class="b">radix_tree_tag_set</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="237" /><span class="True">     237:</span>             <span class="m">unsigned</span> <span class="m">long</span> <span class="b">index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tag</span><span class="f">)</span><span class="f">;</span>
<a name="238" /><span class="True">     238:</span> <span class="m">void</span> <span class="f">*</span><span class="b">radix_tree_tag_clear</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="239" /><span class="True">     239:</span>             <span class="m">unsigned</span> <span class="m">long</span> <span class="b">index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tag</span><span class="f">)</span><span class="f">;</span>
<a name="240" /><span class="True">     240:</span> <span class="m">int</span> <span class="b">radix_tree_tag_get</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="241" /><span class="True">     241:</span>             <span class="m">unsigned</span> <span class="m">long</span> <span class="b">index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tag</span><span class="f">)</span><span class="f">;</span>
<a name="242" /><span class="True">     242:</span> <span class="m">unsigned</span> <span class="m">int</span>
<a name="243" /><span class="True">     243:</span> <span class="b">radix_tree_gang_lookup_tag</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">results</span><span class="f">,</span>
<a name="244" /><span class="True">     244:</span>         <span class="m">unsigned</span> <span class="m">long</span> <span class="b">first_index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">max_items</span><span class="f">,</span>
<a name="245" /><span class="True">     245:</span>         <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tag</span><span class="f">)</span><span class="f">;</span>
<a name="246" /><span class="True">     246:</span> <span class="m">unsigned</span> <span class="m">int</span>
<a name="247" /><span class="True">     247:</span> <span class="b">radix_tree_gang_lookup_tag_slot</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="f">*</span><span class="b">results</span><span class="f">,</span>
<a name="248" /><span class="True">     248:</span>         <span class="m">unsigned</span> <span class="m">long</span> <span class="b">first_index</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">max_items</span><span class="f">,</span>
<a name="249" /><span class="True">     249:</span>         <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tag</span><span class="f">)</span><span class="f">;</span>
<a name="250" /><span class="True">     250:</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">radix_tree_range_tag_if_tagged</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="251" /><span class="True">     251:</span>         <span class="m">unsigned</span> <span class="m">long</span> <span class="f">*</span><span class="b">first_indexp</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">last_index</span><span class="f">,</span>
<a name="252" /><span class="True">     252:</span>         <span class="m">unsigned</span> <span class="m">long</span> <span class="b">nr_to_tag</span><span class="f">,</span>
<a name="253" /><span class="True">     253:</span>         <span class="m">unsigned</span> <span class="m">int</span> <span class="b">fromtag</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">totag</span><span class="f">)</span><span class="f">;</span>
<a name="254" /><span class="True">     254:</span> <span class="m">int</span> <span class="b">radix_tree_tagged</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">int</span> <span class="b">tag</span><span class="f">)</span><span class="f">;</span>
<a name="255" /><span class="True">     255:</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">radix_tree_locate_item</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span> <span class="m">void</span> <span class="f">*</span><span class="b">item</span><span class="f">)</span><span class="f">;</span>
<a name="256" /><span class="True">     256:</span> 
<a name="257" /><span class="True">     257:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">radix_tree_preload_end</span><span class="f">(</span><span class="m">void</span><span class="f">)</span>
<a name="258" /><span class="True">     258:</span> <span class="f">{</span>
<a name="259" /><span class="True">     259:</span>     <a href="cpu.c_macros_ref.html#_cHJlZW1wdF9lbmFibGVfMA__"><span class="b">preempt_enable</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="260" /><span class="True">     260:</span> <span class="f">}</span>
<a name="261" /><span class="True">     261:</span> 
<a name="262" /><span class="True">     262:</span> <span class="k">/**</span>
<a name="263" /><span class="True">     263:</span> <span class="k"> * struct radix_tree_iter - radix tree iterator state</span>
<a name="264" /><span class="True">     264:</span> <span class="k"> *</span>
<a name="265" /><span class="True">     265:</span> <span class="k"> * @index:    index of current slot</span>
<a name="266" /><span class="True">     266:</span> <span class="k"> * @next_index:    next-to-last index for this chunk</span>
<a name="267" /><span class="True">     267:</span> <span class="k"> * @tags:    bit-mask for tag-iterating</span>
<a name="268" /><span class="True">     268:</span> <span class="k"> *</span>
<a name="269" /><span class="True">     269:</span> <span class="k"> * This radix tree iterator works in terms of &quot;chunks&quot; of slots.  A chunk is a</span>
<a name="270" /><span class="True">     270:</span> <span class="k"> * subinterval of slots contained within one radix tree leaf node.  It is</span>
<a name="271" /><span class="True">     271:</span> <span class="k"> * described by a pointer to its first slot and a struct radix_tree_iter</span>
<a name="272" /><span class="True">     272:</span> <span class="k"> * which holds the chunk&apos;s position in the tree and its size.  For tagged</span>
<a name="273" /><span class="True">     273:</span> <span class="k"> * iteration radix_tree_iter also holds the slots&apos; bit-mask for one chosen</span>
<a name="274" /><span class="True">     274:</span> <span class="k"> * radix tree tag.</span>
<a name="275" /><span class="True">     275:</span> <span class="k"> */</span>
<a name="276" /><span class="True">     276:</span> <span class="m">struct</span> <span class="b">radix_tree_iter</span> <span class="f">{</span>
<a name="277" /><span class="True">     277:</span>     <span class="m">unsigned</span> <span class="m">long</span>    <span class="b">index</span><span class="f">;</span>
<a name="278" /><span class="True">     278:</span>     <span class="m">unsigned</span> <span class="m">long</span>    <span class="b">next_index</span><span class="f">;</span>
<a name="279" /><span class="True">     279:</span>     <span class="m">unsigned</span> <span class="m">long</span>    <span class="b">tags</span><span class="f">;</span>
<a name="280" /><span class="True">     280:</span> <span class="f">}</span><span class="f">;</span>
<a name="281" /><span class="True">     281:</span> 
<a name="282" /><span class="True">     282:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_UkFESVhfVFJFRV9JVEVSX1RBR19NQVNLXzA_"><span class="b">RADIX_TREE_ITER_TAG_MASK</span></a>    <span class="c">0x00FF</span>    <span class="k">/* tag index in lower byte */</span>
<a name="283" /><span class="True">     283:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX1RBR0dFRF8w"><span class="b">RADIX_TREE_ITER_TAGGED</span></a>        <span class="c">0x0100</span>    <span class="k">/* lookup tagged slots */</span>
<a name="284" /><span class="True">     284:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX0NPTlRJR18w"><span class="b">RADIX_TREE_ITER_CONTIG</span></a>        <span class="c">0x0200</span>    <span class="k">/* stop at first hole */</span>
<a name="285" /><span class="True">     285:</span> 
<a name="286" /><span class="True">     286:</span> <span class="k">/**</span>
<a name="287" /><span class="True">     287:</span> <span class="k"> * radix_tree_iter_init - initialize radix tree iterator</span>
<a name="288" /><span class="True">     288:</span> <span class="k"> *</span>
<a name="289" /><span class="True">     289:</span> <span class="k"> * @iter:    pointer to iterator state</span>
<a name="290" /><span class="True">     290:</span> <span class="k"> * @start:    iteration starting index</span>
<a name="291" /><span class="True">     291:</span> <span class="k"> * Returns:    NULL</span>
<a name="292" /><span class="True">     292:</span> <span class="k"> */</span>
<a name="293" /><span class="True">     293:</span> <span class="m">static</span> <a href="cpu.c_macros_ref.html#_X19hbHdheXNfaW5saW5lXzA_"><span class="b">__always_inline</span></a> <span class="m">void</span> <span class="f">*</span><span class="f">*</span>
<a name="294" /><span class="True">     294:</span> <span class="b">radix_tree_iter_init</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_iter</span> <span class="f">*</span><span class="b">iter</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">start</span><span class="f">)</span>
<a name="295" /><span class="True">     295:</span> <span class="f">{</span>
<a name="296" /><span class="True">     296:</span>     <span class="k">/*</span>
<a name="297" /><span class="True">     297:</span> <span class="k">     * Leave iter-&gt;tags uninitialized. radix_tree_next_chunk() will fill it</span>
<a name="298" /><span class="True">     298:</span> <span class="k">     * in the case of a successful tagged chunk lookup.  If the lookup was</span>
<a name="299" /><span class="True">     299:</span> <span class="k">     * unsuccessful or non-tagged then nobody cares about -&gt;tags.</span>
<a name="300" /><span class="True">     300:</span> <span class="k">     *</span>
<a name="301" /><span class="True">     301:</span> <span class="k">     * Set index to zero to bypass next_index overflow protection.</span>
<a name="302" /><span class="True">     302:</span> <span class="k">     * See the comment in radix_tree_next_chunk() for details.</span>
<a name="303" /><span class="True">     303:</span> <span class="k">     */</span>
<a name="304" /><span class="True">     304:</span>     <span class="b">iter</span><span class="f">-&gt;</span><span class="b">index</span> <span class="f">=</span> <span class="c">0</span><span class="f">;</span>
<a name="305" /><span class="True">     305:</span>     <span class="b">iter</span><span class="f">-&gt;</span><span class="b">next_index</span> <span class="f">=</span> <span class="b">start</span><span class="f">;</span>
<a name="306" /><span class="True">     306:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>
<a name="307" /><span class="True">     307:</span> <span class="f">}</span>
<a name="308" /><span class="True">     308:</span> 
<a name="309" /><span class="True">     309:</span> <span class="k">/**</span>
<a name="310" /><span class="True">     310:</span> <span class="k"> * radix_tree_next_chunk - find next chunk of slots for iteration</span>
<a name="311" /><span class="True">     311:</span> <span class="k"> *</span>
<a name="312" /><span class="True">     312:</span> <span class="k"> * @root:    radix tree root</span>
<a name="313" /><span class="True">     313:</span> <span class="k"> * @iter:    iterator state</span>
<a name="314" /><span class="True">     314:</span> <span class="k"> * @flags:    RADIX_TREE_ITER_* flags and tag index</span>
<a name="315" /><span class="True">     315:</span> <span class="k"> * Returns:    pointer to chunk first slot, or NULL if there no more left</span>
<a name="316" /><span class="True">     316:</span> <span class="k"> *</span>
<a name="317" /><span class="True">     317:</span> <span class="k"> * This function looks up the next chunk in the radix tree starting from</span>
<a name="318" /><span class="True">     318:</span> <span class="k"> * @iter-&gt;next_index.  It returns a pointer to the chunk&apos;s first slot.</span>
<a name="319" /><span class="True">     319:</span> <span class="k"> * Also it fills @iter with data about chunk: position in the tree (index),</span>
<a name="320" /><span class="True">     320:</span> <span class="k"> * its end (next_index), and constructs a bit mask for tagged iterating (tags).</span>
<a name="321" /><span class="True">     321:</span> <span class="k"> */</span>
<a name="322" /><span class="True">     322:</span> <span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">radix_tree_next_chunk</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_root</span> <span class="f">*</span><span class="b">root</span><span class="f">,</span>
<a name="323" /><span class="True">     323:</span>                  <span class="m">struct</span> <span class="b">radix_tree_iter</span> <span class="f">*</span><span class="b">iter</span><span class="f">,</span> <span class="m">unsigned</span> <span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="324" /><span class="True">     324:</span> 
<a name="325" /><span class="True">     325:</span> <span class="k">/**</span>
<a name="326" /><span class="True">     326:</span> <span class="k"> * radix_tree_chunk_size - get current chunk size</span>
<a name="327" /><span class="True">     327:</span> <span class="k"> *</span>
<a name="328" /><span class="True">     328:</span> <span class="k"> * @iter:    pointer to radix tree iterator</span>
<a name="329" /><span class="True">     329:</span> <span class="k"> * Returns:    current chunk size</span>
<a name="330" /><span class="True">     330:</span> <span class="k"> */</span>
<a name="331" /><span class="True">     331:</span> <span class="m">static</span> <a href="cpu.c_macros_ref.html#_X19hbHdheXNfaW5saW5lXzA_"><span class="b">__always_inline</span></a> <span class="m">unsigned</span>
<a name="332" /><span class="True">     332:</span> <span class="b">radix_tree_chunk_size</span><span class="f">(</span><span class="m">struct</span> <span class="b">radix_tree_iter</span> <span class="f">*</span><span class="b">iter</span><span class="f">)</span>
<a name="333" /><span class="True">     333:</span> <span class="f">{</span>
<a name="334" /><span class="True">     334:</span>     <span class="m">return</span> <span class="b">iter</span><span class="f">-&gt;</span><span class="b">next_index</span> <span class="f">-</span> <span class="b">iter</span><span class="f">-&gt;</span><span class="b">index</span><span class="f">;</span>
<a name="335" /><span class="True">     335:</span> <span class="f">}</span>
<a name="336" /><span class="True">     336:</span> 
<a name="337" /><span class="True">     337:</span> <span class="k">/**</span>
<a name="338" /><span class="True">     338:</span> <span class="k"> * radix_tree_next_slot - find next slot in chunk</span>
<a name="339" /><span class="True">     339:</span> <span class="k"> *</span>
<a name="340" /><span class="True">     340:</span> <span class="k"> * @slot:    pointer to current slot</span>
<a name="341" /><span class="True">     341:</span> <span class="k"> * @iter:    pointer to interator state</span>
<a name="342" /><span class="True">     342:</span> <span class="k"> * @flags:    RADIX_TREE_ITER_*, should be constant</span>
<a name="343" /><span class="True">     343:</span> <span class="k"> * Returns:    pointer to next slot, or NULL if there no more left</span>
<a name="344" /><span class="True">     344:</span> <span class="k"> *</span>
<a name="345" /><span class="True">     345:</span> <span class="k"> * This function updates @iter-&gt;index in the case of a successful lookup.</span>
<a name="346" /><span class="True">     346:</span> <span class="k"> * For tagged lookup it also eats @iter-&gt;tags.</span>
<a name="347" /><span class="True">     347:</span> <span class="k"> */</span>
<a name="348" /><span class="True">     348:</span> <span class="m">static</span> <a href="cpu.c_macros_ref.html#_X19hbHdheXNfaW5saW5lXzA_"><span class="b">__always_inline</span></a> <span class="m">void</span> <span class="f">*</span><span class="f">*</span>
<a name="349" /><span class="True">     349:</span> <span class="b">radix_tree_next_slot</span><span class="f">(</span><span class="m">void</span> <span class="f">*</span><span class="f">*</span><span class="b">slot</span><span class="f">,</span> <span class="m">struct</span> <span class="b">radix_tree_iter</span> <span class="f">*</span><span class="b">iter</span><span class="f">,</span> <span class="m">unsigned</span> <span class="b">flags</span><span class="f">)</span>
<a name="350" /><span class="True">     350:</span> <span class="f">{</span>
<a name="351" /><span class="True">     351:</span>     <span class="m">if</span> <span class="f">(</span><span class="b">flags</span> <span class="f">&amp;</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX1RBR0dFRF8w"><span class="b">RADIX_TREE_ITER_TAGGED</span></a><span class="f">)</span> <span class="f">{</span>
<a name="352" /><span class="True">     352:</span>         <span class="b">iter</span><span class="f">-&gt;</span><span class="b">tags</span> <span class="f">&gt;&gt;=</span> <span class="c">1</span><span class="f">;</span>
<a name="353" /><span class="True">     353:</span>         <span class="m">if</span> <span class="f">(</span><a href="cpu.c_macros_ref.html#_bGlrZWx5XzA_"><span class="b">likely</span></a><span class="f">(</span><span class="b">iter</span><span class="f">-&gt;</span><span class="b">tags</span> <span class="f">&amp;</span> <span class="c">1ul</span><span class="f">)</span><span class="f">)</span> <span class="f">{</span>
<a name="354" /><span class="True">     354:</span>             <span class="b">iter</span><span class="f">-&gt;</span><span class="b">index</span><span class="f">++</span><span class="f">;</span>
<a name="355" /><span class="True">     355:</span>             <span class="m">return</span> <span class="b">slot</span> <span class="f">+</span> <span class="c">1</span><span class="f">;</span>
<a name="356" /><span class="True">     356:</span>         <span class="f">}</span>
<a name="357" /><span class="True">     357:</span>         <span class="m">if</span> <span class="f">(</span><span class="f">!</span><span class="f">(</span><span class="b">flags</span> <span class="f">&amp;</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX0NPTlRJR18w"><span class="b">RADIX_TREE_ITER_CONTIG</span></a><span class="f">)</span> <span class="f">&amp;&amp;</span> <a href="cpu.c_macros_ref.html#_bGlrZWx5XzA_"><span class="b">likely</span></a><span class="f">(</span><span class="b">iter</span><span class="f">-&gt;</span><span class="b">tags</span><span class="f">)</span><span class="f">)</span> <span class="f">{</span>
<a name="358" /><span class="True">     358:</span>             <span class="m">unsigned</span> <span class="b">offset</span> <span class="f">=</span> <span class="b">__ffs</span><span class="f">(</span><span class="b">iter</span><span class="f">-&gt;</span><span class="b">tags</span><span class="f">)</span><span class="f">;</span>
<a name="359" /><span class="True">     359:</span> 
<a name="360" /><span class="True">     360:</span>             <span class="b">iter</span><span class="f">-&gt;</span><span class="b">tags</span> <span class="f">&gt;&gt;=</span> <span class="b">offset</span><span class="f">;</span>
<a name="361" /><span class="True">     361:</span>             <span class="b">iter</span><span class="f">-&gt;</span><span class="b">index</span> <span class="f">+=</span> <span class="b">offset</span> <span class="f">+</span> <span class="c">1</span><span class="f">;</span>
<a name="362" /><span class="True">     362:</span>             <span class="m">return</span> <span class="b">slot</span> <span class="f">+</span> <span class="b">offset</span> <span class="f">+</span> <span class="c">1</span><span class="f">;</span>
<a name="363" /><span class="True">     363:</span>         <span class="f">}</span>
<a name="364" /><span class="True">     364:</span>     <span class="f">}</span> <span class="m">else</span> <span class="f">{</span>
<a name="365" /><span class="True">     365:</span>         <span class="m">unsigned</span> <span class="b">size</span> <span class="f">=</span> <span class="b">radix_tree_chunk_size</span><span class="f">(</span><span class="b">iter</span><span class="f">)</span> <span class="f">-</span> <span class="c">1</span><span class="f">;</span>
<a name="366" /><span class="True">     366:</span> 
<a name="367" /><span class="True">     367:</span>         <span class="m">while</span> <span class="f">(</span><span class="b">size</span><span class="f">--</span><span class="f">)</span> <span class="f">{</span>
<a name="368" /><span class="True">     368:</span>             <span class="b">slot</span><span class="f">++</span><span class="f">;</span>
<a name="369" /><span class="True">     369:</span>             <span class="b">iter</span><span class="f">-&gt;</span><span class="b">index</span><span class="f">++</span><span class="f">;</span>
<a name="370" /><span class="True">     370:</span>             <span class="m">if</span> <span class="f">(</span><a href="cpu.c_macros_ref.html#_bGlrZWx5XzA_"><span class="b">likely</span></a><span class="f">(</span><span class="f">*</span><span class="b">slot</span><span class="f">)</span><span class="f">)</span>
<a name="371" /><span class="True">     371:</span>                 <span class="m">return</span> <span class="b">slot</span><span class="f">;</span>
<a name="372" /><span class="True">     372:</span>             <span class="m">if</span> <span class="f">(</span><span class="b">flags</span> <span class="f">&amp;</span> <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX0NPTlRJR18w"><span class="b">RADIX_TREE_ITER_CONTIG</span></a><span class="f">)</span> <span class="f">{</span>
<a name="373" /><span class="True">     373:</span>                 <span class="k">/* forbid switching to the next chunk */</span>
<a name="374" /><span class="True">     374:</span>                 <span class="b">iter</span><span class="f">-&gt;</span><span class="b">next_index</span> <span class="f">=</span> <span class="c">0</span><span class="f">;</span>
<a name="375" /><span class="True">     375:</span>                 <span class="m">break</span><span class="f">;</span>
<a name="376" /><span class="True">     376:</span>             <span class="f">}</span>
<a name="377" /><span class="True">     377:</span>         <span class="f">}</span>
<a name="378" /><span class="True">     378:</span>     <span class="f">}</span>
<a name="379" /><span class="True">     379:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">;</span>
<a name="380" /><span class="True">     380:</span> <span class="f">}</span>
<a name="381" /><span class="True">     381:</span> 
<a name="382" /><span class="True">     382:</span> <span class="k">/**</span>
<a name="383" /><span class="True">     383:</span> <span class="k"> * radix_tree_for_each_chunk - iterate over chunks</span>
<a name="384" /><span class="True">     384:</span> <span class="k"> *</span>
<a name="385" /><span class="True">     385:</span> <span class="k"> * @slot:    the void** variable for pointer to chunk first slot</span>
<a name="386" /><span class="True">     386:</span> <span class="k"> * @root:    the struct radix_tree_root pointer</span>
<a name="387" /><span class="True">     387:</span> <span class="k"> * @iter:    the struct radix_tree_iter pointer</span>
<a name="388" /><span class="True">     388:</span> <span class="k"> * @start:    iteration starting index</span>
<a name="389" /><span class="True">     389:</span> <span class="k"> * @flags:    RADIX_TREE_ITER_* and tag index</span>
<a name="390" /><span class="True">     390:</span> <span class="k"> *</span>
<a name="391" /><span class="True">     391:</span> <span class="k"> * Locks can be released and reacquired between iterations.</span>
<a name="392" /><span class="True">     392:</span> <span class="k"> */</span>
<a name="393" /><span class="True">     393:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_cmFkaXhfdHJlZV9mb3JfZWFjaF9jaHVua18w"><span class="b">radix_tree_for_each_chunk</span></a><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span>    \
<a name="394" /><span class="True">     394:</span>     <span class="m">for</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_iter_init</span><span class="f">(</span><span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span> <span class="f">;</span>            \
<a name="395" /><span class="True">     395:</span>           <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_chunk</span><span class="f">(</span><span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span><span class="f">)</span> <span class="f">;</span><span class="f">)</span>
<a name="396" /><span class="True">     396:</span> 
<a name="397" /><span class="True">     397:</span> <span class="k">/**</span>
<a name="398" /><span class="True">     398:</span> <span class="k"> * radix_tree_for_each_chunk_slot - iterate over slots in one chunk</span>
<a name="399" /><span class="True">     399:</span> <span class="k"> *</span>
<a name="400" /><span class="True">     400:</span> <span class="k"> * @slot:    the void** variable, at the beginning points to chunk first slot</span>
<a name="401" /><span class="True">     401:</span> <span class="k"> * @iter:    the struct radix_tree_iter pointer</span>
<a name="402" /><span class="True">     402:</span> <span class="k"> * @flags:    RADIX_TREE_ITER_*, should be constant</span>
<a name="403" /><span class="True">     403:</span> <span class="k"> *</span>
<a name="404" /><span class="True">     404:</span> <span class="k"> * This macro is designed to be nested inside radix_tree_for_each_chunk().</span>
<a name="405" /><span class="True">     405:</span> <span class="k"> * @slot points to the radix tree slot, @iter-&gt;index contains its index.</span>
<a name="406" /><span class="True">     406:</span> <span class="k"> */</span>
<a name="407" /><span class="True">     407:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_cmFkaXhfdHJlZV9mb3JfZWFjaF9jaHVua19zbG90XzA_"><span class="b">radix_tree_for_each_chunk_slot</span></a><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span>        \
<a name="408" /><span class="True">     408:</span>     <span class="m">for</span> <span class="f">(</span><span class="f">;</span> <span class="b">slot</span> <span class="f">;</span> <span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_slot</span><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span><span class="f">)</span>
<a name="409" /><span class="True">     409:</span> 
<a name="410" /><span class="True">     410:</span> <span class="k">/**</span>
<a name="411" /><span class="True">     411:</span> <span class="k"> * radix_tree_for_each_slot - iterate over non-empty slots</span>
<a name="412" /><span class="True">     412:</span> <span class="k"> *</span>
<a name="413" /><span class="True">     413:</span> <span class="k"> * @slot:    the void** variable for pointer to slot</span>
<a name="414" /><span class="True">     414:</span> <span class="k"> * @root:    the struct radix_tree_root pointer</span>
<a name="415" /><span class="True">     415:</span> <span class="k"> * @iter:    the struct radix_tree_iter pointer</span>
<a name="416" /><span class="True">     416:</span> <span class="k"> * @start:    iteration starting index</span>
<a name="417" /><span class="True">     417:</span> <span class="k"> *</span>
<a name="418" /><span class="True">     418:</span> <span class="k"> * @slot points to radix tree slot, @iter-&gt;index contains its index.</span>
<a name="419" /><span class="True">     419:</span> <span class="k"> */</span>
<a name="420" /><span class="True">     420:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_cmFkaXhfdHJlZV9mb3JfZWFjaF9zbG90XzA_"><span class="b">radix_tree_for_each_slot</span></a><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span>        \
<a name="421" /><span class="True">     421:</span>     <span class="m">for</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_iter_init</span><span class="f">(</span><span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span> <span class="f">;</span>            \
<a name="422" /><span class="True">     422:</span>          <span class="b">slot</span> <span class="f">||</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_chunk</span><span class="f">(</span><span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="c">0</span><span class="f">)</span><span class="f">)</span> <span class="f">;</span>    \
<a name="423" /><span class="True">     423:</span>          <span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_slot</span><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="c">0</span><span class="f">)</span><span class="f">)</span>
<a name="424" /><span class="True">     424:</span> 
<a name="425" /><span class="True">     425:</span> <span class="k">/**</span>
<a name="426" /><span class="True">     426:</span> <span class="k"> * radix_tree_for_each_contig - iterate over contiguous slots</span>
<a name="427" /><span class="True">     427:</span> <span class="k"> *</span>
<a name="428" /><span class="True">     428:</span> <span class="k"> * @slot:    the void** variable for pointer to slot</span>
<a name="429" /><span class="True">     429:</span> <span class="k"> * @root:    the struct radix_tree_root pointer</span>
<a name="430" /><span class="True">     430:</span> <span class="k"> * @iter:    the struct radix_tree_iter pointer</span>
<a name="431" /><span class="True">     431:</span> <span class="k"> * @start:    iteration starting index</span>
<a name="432" /><span class="True">     432:</span> <span class="k"> *</span>
<a name="433" /><span class="True">     433:</span> <span class="k"> * @slot points to radix tree slot, @iter-&gt;index contains its index.</span>
<a name="434" /><span class="True">     434:</span> <span class="k"> */</span>
<a name="435" /><span class="True">     435:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_cmFkaXhfdHJlZV9mb3JfZWFjaF9jb250aWdfMA__"><span class="b">radix_tree_for_each_contig</span></a><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span>        \
<a name="436" /><span class="True">     436:</span>     <span class="m">for</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_iter_init</span><span class="f">(</span><span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span> <span class="f">;</span>            \
<a name="437" /><span class="True">     437:</span>          <span class="b">slot</span> <span class="f">||</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_chunk</span><span class="f">(</span><span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span>        \
<a name="438" /><span class="True">     438:</span>                 <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX0NPTlRJR18w"><span class="b">RADIX_TREE_ITER_CONTIG</span></a><span class="f">)</span><span class="f">)</span> <span class="f">;</span>        \
<a name="439" /><span class="True">     439:</span>          <span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_slot</span><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span>            \
<a name="440" /><span class="True">     440:</span>                 <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX0NPTlRJR18w"><span class="b">RADIX_TREE_ITER_CONTIG</span></a><span class="f">)</span><span class="f">)</span>
<a name="441" /><span class="True">     441:</span> 
<a name="442" /><span class="True">     442:</span> <span class="k">/**</span>
<a name="443" /><span class="True">     443:</span> <span class="k"> * radix_tree_for_each_tagged - iterate over tagged slots</span>
<a name="444" /><span class="True">     444:</span> <span class="k"> *</span>
<a name="445" /><span class="True">     445:</span> <span class="k"> * @slot:    the void** variable for pointer to slot</span>
<a name="446" /><span class="True">     446:</span> <span class="k"> * @root:    the struct radix_tree_root pointer</span>
<a name="447" /><span class="True">     447:</span> <span class="k"> * @iter:    the struct radix_tree_iter pointer</span>
<a name="448" /><span class="True">     448:</span> <span class="k"> * @start:    iteration starting index</span>
<a name="449" /><span class="True">     449:</span> <span class="k"> * @tag:    tag index</span>
<a name="450" /><span class="True">     450:</span> <span class="k"> *</span>
<a name="451" /><span class="True">     451:</span> <span class="k"> * @slot points to radix tree slot, @iter-&gt;index contains its index.</span>
<a name="452" /><span class="True">     452:</span> <span class="k"> */</span>
<a name="453" /><span class="True">     453:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_cmFkaXhfdHJlZV9mb3JfZWFjaF90YWdnZWRfMA__"><span class="b">radix_tree_for_each_tagged</span></a><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">,</span> <span class="b">tag</span><span class="f">)</span>    \
<a name="454" /><span class="True">     454:</span>     <span class="m">for</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_iter_init</span><span class="f">(</span><span class="b">iter</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span> <span class="f">;</span>            \
<a name="455" /><span class="True">     455:</span>          <span class="b">slot</span> <span class="f">||</span> <span class="f">(</span><span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_chunk</span><span class="f">(</span><span class="b">root</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span>        \
<a name="456" /><span class="True">     456:</span>                   <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX1RBR0dFRF8w"><span class="b">RADIX_TREE_ITER_TAGGED</span></a> <span class="f">|</span> <span class="b">tag</span><span class="f">)</span><span class="f">)</span> <span class="f">;</span>        \
<a name="457" /><span class="True">     457:</span>          <span class="b">slot</span> <span class="f">=</span> <span class="b">radix_tree_next_slot</span><span class="f">(</span><span class="b">slot</span><span class="f">,</span> <span class="b">iter</span><span class="f">,</span>            \
<a name="458" /><span class="True">     458:</span>                 <a href="cpu.c_macros_ref.html#_UkFESVhfVFJFRV9JVEVSX1RBR0dFRF8w"><span class="b">RADIX_TREE_ITER_TAGGED</span></a><span class="f">)</span><span class="f">)</span>
<a name="459" /><span class="True">     459:</span> 
<a name="460" /><span class="True">     460:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* _LINUX_RADIX_TREE_H */</span>
<a name="461" /><span class="True">     461:</span> </pre>
  </body>
</html>
